import regexp from './regexp'

const jude = {
    type (arg) {
        if (jude.isNumber(arg) && isNaN(arg)) {
            return 'NaN'
        } else {
            return Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()
        }
    },
    isArray: Array.isArray,
    isObject (arg) {
        return arg !== null && jude.type(arg) === 'object'
    },
    isString (arg) {
        return typeof arg === 'string'
    },
    isBoolean (arg) {
        return typeof arg === 'boolean'
    },
    isNumber (arg) {
        return typeof arg === 'number'
    },
    isFunction (arg) {
        return typeof arg === 'function'
    },
    isNumberOfNaN (arg) {
        if (!!arg && typeof arg === 'string') {
            arg = Number(arg)
        }
        return typeof arg === 'number' && !isNaN(arg)
    },
    /**
     * 判断是否为空对象或数组
     * @param arg
     * @param bol {boolean}
     * @returns {boolean}
     */
    isEmptyObject (arg, bol = false) {
        if (jude.isEmpty(arg)) return true;
        else if (jude.isArray(arg) && !bol) return 0 === arg.length;
        else if (jude.isObject(arg)) return 0 === Object.keys(arg).length;
        return true
    },
    /**
     * 判断是否为空数组
     * @param arg
     * @param bol {boolean}
     * @returns {boolean}
     */
    isEmptyArray (arg) {
        if (jude.isEmpty(arg)) return true;
        else if (jude.isArray(arg)) return 0 === arg.length;
        return true
    },
    /**
     * 判断是否为空
     * @param arg
     * @returns {boolean}
     */
    isEmpty (arg) {
        if (arg === undefined) return true;
        else if (arg === null) return true;
        else if (jude.isNumber(arg) && isNaN(arg)) return true;
        else if (jude.isString(arg) && 0 === arg.length) return true;
        else if (jude.isArray(arg) && 0 === arg.length) return true;
        else if (jude.isObject(arg) && 0 === Object.keys(arg).length) return true;
        return false
    },
    /**
     * 判断是否为空 ()
     * @param arg
     * @returns {boolean}
     */
    isEmpty2 (arg) {
        if (arg === undefined) return true;
        else if (arg === null) return true;
        else if (jude.isNumber(arg) && isNaN(arg)) return true;
        else if (jude.isArray(arg) && 0 === arg.length) return true;
        else if (jude.isObject(arg) && 0 === Object.keys(arg).length) return true;
        return false
    },
    /**
     * 数据是否相等
     * @param a
     * @param b
     * @param map
     * @returns {boolean}
     */
    isEqual (a, b, map = []) {
        //如果a和b本来就全等
        if (a === b) {
            //判断是否为0和-0
            return a !== 0 || 1 / a === 1 / b
        }
        //判断是否为null和undefined
        if (a == null || b == null) {
            return a === b
        }
        //接下来判断a和b的数据类型
        let classNameA = toString.call(a),
            classNameB = toString.call(b)
        //如果数据类型不相等，则返回false
        if (classNameA !== classNameB) {
            return false
        }
        //如果数据类型相等，再根据不同数据类型分别判断
        switch (classNameA) {
            case '[object RegExp]':
            case '[object String]':
                //进行字符串转换比较
                return '' + a === '' + b
            case '[object Number]':
                //进行数字转换比较,判断是否为NaN
                if (+a !== +a) {
                    return +b !== +b
                }
                //判断是否为0或-0
                return +a === 0 ? 1 / +a === 1 / b : +a === +b
            case '[object Date]':
            case '[object Boolean]':
                return +a === +b
        }
        //如果是对象类型
        if (classNameA === '[object Object]') {
            //获取a和b的属性长度
            let propsA = Object.getOwnPropertyNames(a),
                propsB = Object.getOwnPropertyNames(b)
            if (propsA.length != propsB.length) {
                return false
            }
            for (let i = 0; i < propsA.length; i++) {
                let propName = propsA[i];
                //如果对应属性对应值不相等，则返回false
                if (a[propName] !== b[propName] && map.indexOf(propName) === -1) {
                    return false
                }
            }
            return true
        }
        //如果是数组类型
        if (classNameA === '[object Array]') {
            if (a.toString() === b.toString()) {
                return true
            }
            return false
        }
    },
    /**
     * 判断是否手机号码格式
     * @param mobile {number|string}
     * @param strict {boolean}
     * @returns {boolean}
     */
    isTelephone (mobile, strict = false) {
        let type = jude.type(mobile);
        if (type !== 'number' && type !== 'string') return false;
        if (type === 'number') mobile = mobile + '';
        if (mobile.length < 11) return false;
        if (strict === true) return regexp.telephoneStrict.test(mobile);
        else return regexp.telephone.test(mobile);
    },
    isColor (color) {
        if (!jude.isString(color)) return false;
        return regexp.color.test(color)
    },
    colorFilter (color) {
        if (jude.isColor(color)) {
            const colorStr = color.replace(/#/ig, '');
            if (regexp.colorShort.test(colorStr)) {
                return `#${colorStr}${colorStr}`
            } else {
                return color
            }
        } else {
            return '';
        }
    },
    // 密码验证
    isPwdVerify (pwd) {
        if (jude.isNumber(pwd)) pwd = pwd + '';
        let level = 0;
        if (!jude.isString(pwd) || pwd.length < 6) return level;
        switch (true) {
            case regexp.lowPwd.test(pwd):
                level = 1;
                break;
            case regexp.inPwd.test(pwd):
                level = 2;
                break;
            case regexp.highPwd.test(pwd):
                level = 3;
                break;
        }
        return level;
    }
}

export default jude
